Page({
  data: {
    isUnLogin: true, // 未登录状态标记，默认未登录
    showDownloadModal: false, // 下载选项弹窗
    videoInfo: {},
    canvasWidth: 0,
    canvasHeight: 0,
    duration: 0,
    originalVideoPath: '', // 未压缩版视频路径（用于页面展示和截图）
    currentTime: 0,
    videoDecoder: null,
    canvas: null,
    context: null,
    videoContext: null,
    isPlaying: false, // 添加播放状态
    // 自定义进度条相关状态
    progressPercent: 0,
    currentTimeFormatted: '00:00',
    durationFormatted: '00:00',
    // 拖动状态
    isDragging: false,
    progressBarWidth: 0,
    progressBarLeft: 0,
    ifShowProcessBar: false,
    // 全屏状态
    isFullscreen: false,
    // 全屏切换时的时间同步标记
    needsSyncAfterFullscreen: false,
    //控制显示视频组件的变量
    processbarId: null,
    playorpauseProcessId: null,
    // 视频源相关状态
    showSourceDropdown: false,
    videoSources: [],   //该列表用来存所有的视频url
    // 双击检测相关状态
    lastTapTime: 0,
    tapTimer: null,
    // 表单相关状态
    showFormModal: false,
    formData: {
      contestNumber: '', // 参赛号
      idCardLastFour: '', // 身份证号后四位
      name: '', // 姓名
      phone: '', // 手机号
      nickname: '' // 昵称
    },

  },

  onLoad(options) {
    // 判断是否是朋友圈分享打开，且包含视频参数
    if (options.fromTimeline && options.videoUrl) {
      // 立即跳转，不加载首页其他内容
      wx.redirectTo({
        url: `/pages/video_viewer/video_viewer?${Object.keys(options).map(key => `${key}=${options[key]}`).join('&')}`
      });
      // 阻止首页其他逻辑执行
      return;
    }
    console.log("页面加载完成");
    const openid = wx.getStorageSync('openid')
    console.log(openid)
    this.setData({
      videoContext: wx.createVideoContext('mainVideo') //1 获取组件的控制权 创建控制对象 2 提供视频操作方法（通过返回的对象控制视频播放 暂停 跳转）
    });
    this.checkLoginStatus(); // 新增：检查登录状态
  },

  onReady() {
    // 页面渲染完成后，获取进度条尺寸并缓存
    this.getProgressBarDimensions();
  },

  // 切换视频源下拉列表的显示/隐藏
  toggleVideoSourceDropdown() {
    this.setData({
      showSourceDropdown: !this.data.showSourceDropdown
    });
  },

  // 切换视频源
  async changeVideoSource(e) {
    const index = e.currentTarget.dataset.index;
    const selectedSource = this.data.videoSources[index];

    // 隐藏下拉列表
    this.setData({
      showSourceDropdown: false
    });

    const videoUrl = selectedSource;
      console.log('获取的视频URL:', videoUrl);

      const downloadRes = await new Promise((resolve, reject) => {
        wx.downloadFile({
          url: videoUrl,
          success: resolve,
          fail: reject
        });
      });
      console.log('下载的临时路径', downloadRes.tempFilePath)
      // 获取视频信息
      const videoInfo = await new Promise((resolve, reject) => {
        wx.getVideoInfo({
          src: downloadRes.tempFilePath,
          success: (res) => {
            if (res.statusCode === 200 && res.totalBytesWritten > 1024) {
              console.log('下载成功，文件大小:', res.totalBytesWritten, 'Bytes');
            }
            resolve(res); // 必须调用resolve
          },
          fail: (err) => {
            console.log('请求失败', err);
            reject(err);
          }
        });
      });
      // 5. 设置页面数据
      this.setData({
        originalVideoPath: downloadRes.tempFilePath,
        currentTime: 0,
        duration: videoInfo.duration,
        durationFormatted: this.formatTime(videoInfo.duration),
        currentTimeFormatted: this.formatTime(0, true),
        progressPercent: 0
      });
      console.log('原始视频临时路径', this.data.originalVideoPath)

      // 6. 初始化截图用的解码器
      await this.initScreenshotDecoder();

      wx.hideLoading();

  },

  // 切换播放/暂停状态并阻止事件冒泡
  togglePlayPauseStopPropagation(e) {
    // 阻止事件冒泡到父元素 - 使用微信小程序兼容的方式
    if (e && typeof e.stopPropagation === 'function') {
      e.stopPropagation();
    }
    this.togglePlayPause();
  },

  // 切换全屏状态并阻止事件冒泡
  toggleFullscreenStopPropagation(e) {
    // 阻止事件冒泡到父元素 - 使用微信小程序兼容的方式
    if (e && typeof e.stopPropagation === 'function') {
      e.stopPropagation();
    }
    this.toggleFullscreen();
  },

  // 切换全屏状态
  toggleFullscreen() {
    // 保存当前播放状态，确保切换全屏时保持不变
    const currentPlayingState = this.data.isPlaying;

    if (this.data.isFullscreen) {
      // 获取全屏视频的当前时间
      const fullscreenVideoContext = wx.createVideoContext('fullscreenVideo', this);
      const lastFullscreenTime = this.data.currentTime; // 保存最后记录的时间

      // 退出全屏
      this.setData({
        isFullscreen: false
      });

      // 短暂延迟，确保非全屏视频组件已渲染，然后恢复播放状态和同步时间
      setTimeout(() => {
        const mainVideoContext = wx.createVideoContext('mainVideo', this);
        if (mainVideoContext) {
          // 强制同步时间到主视频，确保进度条显示正确
          this.setData({
            currentTime: lastFullscreenTime,
            currentTimeFormatted: this.formatTime(lastFullscreenTime, true)
          });

          // 同步实际播放位置
          mainVideoContext.seek(lastFullscreenTime);

          // 恢复播放状态
          if (currentPlayingState) {
            mainVideoContext.play();
          } else {
            mainVideoContext.pause();
          }
        }
      }, 100);
    } else {
      // 进入全屏前先暂停主视频的播放，防止两个视频同时播放
      const mainVideoContext = wx.createVideoContext('mainVideo', this);
      if (mainVideoContext) {
        mainVideoContext.pause();
      }

      // 进入全屏 - 直接显示全屏组件，并设置同步标记
      this.setData({
        isFullscreen: true,
        needsSyncAfterFullscreen: true
      });

      // 由于全屏组件使用了wx:if条件渲染，在setData完成后会立即显示
      // 主动同步主视频的时间和播放状态到全屏视频
      setTimeout(() => {
        const fullscreenVideoContext = wx.createVideoContext('fullscreenVideo', this);
        if (fullscreenVideoContext && this.data.currentTime) {
          fullscreenVideoContext.seek(this.data.currentTime);

          // 根据保存的播放状态，设置全屏视频的播放状态
          if (currentPlayingState) {
            fullscreenVideoContext.play();
          } else {
            fullscreenVideoContext.pause();
          }
        }
      }, 100); // 短暂延迟确保全屏组件已渲染
    }
  },

  // 双击检测处理函数
  handleVideoTap() {
    const currentTime = new Date().getTime();
    const lastTapTime = this.data.lastTapTime;

    // 如果两次点击时间间隔小于300ms，判定为双击
    if (currentTime - lastTapTime < 300) {
      // 是双击，执行播放/暂停切换
      this.togglePlayPause();

      // 清除单击计时器
      if (this.data.tapTimer) {
        clearTimeout(this.data.tapTimer);
        this.setData({
          tapTimer: null
        });
      }
    } else {
      // 是单击，设置计时器等待可能的第二次点击
      const tapTimer = setTimeout(() => {
        // 单击事件处理：切换进度条显示状态
        this.setData({
          tapTimer: null,
          ifShowProcessBar: !this.data.ifShowProcessBar
        });
        
        // 如果显示了进度条，3秒后自动隐藏
        if (this.data.ifShowProcessBar) {
          if (this.data.processbarId) {
            clearTimeout(this.data.processbarId);
          }
          this.data.processbarId = setTimeout(() => {
            this.setData({
              ifShowProcessBar: false
            });
          }, 3000);
        }
      }, 300);

      this.setData({
        lastTapTime: currentTime,
        tapTimer: tapTimer
      });
    }
  },

  // 切换播放/暂停状态
  togglePlayPause() {
    if (this.data.playorpauseProcessId) {
      clearTimeout(this.data.playorpauseProcessId)
      this.setData({
        playorpauseProcessId: null
      })
    }
    // 切换视频播放状态
    const newIsPlaying = !this.data.isPlaying;
    this.setData({
      isPlaying: newIsPlaying,
      ifShowProcessBar: true
    })

    this.data.playorpauseProcessId = setTimeout(() => {
      this.setData({
        ifShowProcessBar: false
      })
    }, 3000)

    // 控制主视频
    if (this.data.videoContext) {
      if (newIsPlaying) {
        this.data.videoContext.play();
      } else {
        this.data.videoContext.pause();
      }
    }

    // 如果在全屏模式下，也控制全屏视频
    if (this.data.isFullscreen) {
      const fullscreenVideoContext = wx.createVideoContext('fullscreenVideo', this);
      if (fullscreenVideoContext) {
        if (newIsPlaying) {
          fullscreenVideoContext.play();
        } else {
          fullscreenVideoContext.pause();
        }
      }
    }
  },

  // 监听视频播放事件
  onPlay() {
    this.setData({
      isPlaying: true
    });
  },

  // 监听视频暂停事件
  onPause() {
    this.setData({
      isPlaying: false
    });
  },

  // 获取进度条尺寸并缓存
  getProgressBarDimensions() {
    const query = wx.createSelectorQuery();
    query.select('.progress-bar').boundingClientRect().exec((res) => {
      if (res && res[0] && res[0].width > 0) {
        this.setData({
          progressBarWidth: res[0].width,
          progressBarLeft: res[0].left
        });
      }
    });
  },

  async selectVideo(res) {
    try {
      // 显示加载提示
      wx.showLoading({
        title: '获取视频中',
        mask: true
      });

      // 1. 获取用户openid
      const app = getApp();
      const openid = app.globalData.openid || wx.getStorageSync('openid');
      console.log(openid)

      if (!openid) {
        throw new Error('用户未登录');
      }

      // 3. 检查返回数据
      if (res.data.code !== 0 || !res.data.data.video_url) {
        throw new Error(res.data.message || '获取视频URL失败');
      }

      const videoUrl = res.data.data.video_url;
      console.log('获取的视频URL:', videoUrl);

      const downloadRes = await new Promise((resolve, reject) => {
        wx.downloadFile({
          url: videoUrl,
          success: resolve,
          fail: reject
        });
      });
      console.log('下载的临时路径', downloadRes.tempFilePath)
      // 获取视频信息
      const videoInfo = await new Promise((resolve, reject) => {
        wx.getVideoInfo({
          src: downloadRes.tempFilePath,
          success: (res) => {
            if (res.statusCode === 200 && res.totalBytesWritten > 1024) {
              console.log('下载成功，文件大小:', res.totalBytesWritten, 'Bytes');
            }
            resolve(res); // 必须调用resolve
          },
          fail: (err) => {
            console.log('请求失败', err);
            reject(err);
          }
        });
      });
      // 5. 设置页面数据
      this.setData({
        originalVideoPath: downloadRes.tempFilePath,
        currentTime: 0,
        duration: videoInfo.duration,
        durationFormatted: this.formatTime(videoInfo.duration),
        currentTimeFormatted: this.formatTime(0, true),
        progressPercent: 0
      });
      console.log('原始视频临时路径', this.data.originalVideoPath)

      // 6. 初始化截图用的解码器
      await this.initScreenshotDecoder();

      wx.hideLoading();

    } catch (error) {
      console.error('获取视频失败:', error);
      wx.hideLoading();
      wx.showToast({
        title: error.message || '获取视频失败',
        icon: 'none'
      });
    }
  },

  // 初始化截图用的视频解码器
  async initScreenshotDecoder() {
    // 确保先停止并清理旧的解码器
    if (this.data.videoDecoder) {
      try {
        this.data.videoDecoder.stop();
        console.log('已停止旧解码器');
      } catch (e) {
        console.error('停止旧解码器出错:', e);
      }
    }

    try {
      // 只使用未压缩版视频
      const videoPath = this.data.originalVideoPath;
      
      if (!videoPath) {
        throw new Error('没有有效的视频路径');
      }

      // 获取视频信息
      const videoInfo = await wx.getVideoInfo({
        src: videoPath,
      });

      this.setData({
        videoInfo: videoInfo,
        canvasWidth: videoInfo.width,
        canvasHeight: videoInfo.height,
        duration: videoInfo.duration
      });

      const {
        canvas,
        context
      } = this.initOffscreenCanvas(
        this.data.canvasWidth,
        this.data.canvasHeight
      );

      // 创建并初始化新的解码器
      const decoder = wx.createVideoDecoder();
      
      // 添加错误监听
      decoder.on('error', (error) => {
        console.error('视频解码器错误:', error);
      });
      
      // 启动解码器
      decoder.start({
        source: videoPath
      });

      this.setData({
        canvas,
        context,
        videoDecoder: decoder
      });

      // 等待解码器准备就绪，增加超时处理
      await new Promise(resolve => {
        decoder.on('start', () => {
          console.log('解码器已成功启动');
          resolve();
        });
        
        // 2秒超时保障，确保不会无限等待
        setTimeout(() => {
          console.log('解码器初始化超时，继续执行');
          resolve();
        }, 2000);
      });
      
      console.log('视频解码器初始化完成');
    } catch (error) {
      console.error('视频解码器初始化过程出错:', error);
      // 清理资源
      if (this.data.videoDecoder) {
        try {
          this.data.videoDecoder.stop();
        } catch (e) {
          console.error('清理解码器资源时出错:', e);
        }
        this.setData({
          videoDecoder: null
        });
      }
      // 重新抛出错误，让调用者知道初始化失败
      throw error;
    }
  },

  // 初始化离屏画布
  initOffscreenCanvas(canvasWidth, canvasHeight) {
    const canvas = wx.createOffscreenCanvas({
      type: '2d',
      width: canvasWidth,
      height: canvasHeight
    });
    return {
      canvas,
      context: canvas.getContext('2d')
    };
  },

  // 格式化时间显示
  formatTime(seconds, showMilliseconds = false) {
    const minutes = Math.floor(seconds / 60);
    const remainingSeconds = Math.floor(seconds % 60);

    if (showMilliseconds) {
      // 获取毫秒部分（保留两位小数）
      const milliseconds = Math.floor((seconds - Math.floor(seconds)) * 100);
      return `${minutes.toString().padStart(2, '0')}:${remainingSeconds.toString().padStart(2, '0')}.${milliseconds.toString().padStart(2, '0')}`;
    }

    return `${minutes.toString().padStart(2, '0')}:${remainingSeconds.toString().padStart(2, '0')}`;
  },

  // 监听视频播放时间更新
  onTimeUpdate(e) {
    // 如果正在拖动，不更新进度条
    if (this.data.isDragging) {
      return;
    }

    // 只处理当前活动视频的时间更新（主视频或全屏视频）
    const currentTargetId = e.currentTarget ? e.currentTarget.id : '';
    const isActiveVideo =
      (currentTargetId === 'mainVideo' && !this.data.isFullscreen) ||
      (currentTargetId === 'fullscreenVideo' && this.data.isFullscreen);

    // 忽略其他视频组件的时间更新事件
    if (!isActiveVideo) {
      return;
    }

    if (e.detail) {
      // 移除toFixed(1)以保留原始精度
      const currentTime = e.detail.currentTime;
      const duration = e.detail.duration || this.data.duration;

      // 增加更新阈值以减少更新频率，避免跳动
      if (Math.abs(currentTime - this.data.currentTime) >= 0.1) {
        const progressPercent = (currentTime / duration) * 100;

        this.setData({
          currentTime: currentTime,
          progressPercent: progressPercent,
          currentTimeFormatted: this.formatTime(currentTime, true), // 启用毫秒显示
          durationFormatted: this.formatTime(duration)
        });
      }
    }

    // 优化全屏模式下的时间同步逻辑
    if (this.data.isFullscreen && currentTargetId === 'mainVideo') {
      // 只在从非全屏切换到全屏时同步一次时间，避免持续同步导致跳动
      if (this.data.needsSyncAfterFullscreen) {
        const fullscreenVideoContext = wx.createVideoContext('fullscreenVideo', this);
        if (fullscreenVideoContext && e.detail) {
          fullscreenVideoContext.seek(e.detail.currentTime);
          this.setData({
            needsSyncAfterFullscreen: false
          });
        }
      }
    }

    // 优化非全屏模式下的时间同步逻辑 - 当从全屏切换回非全屏时
    // 只有在全屏视频触发时间更新且当前是非全屏状态时才同步
    if (!this.data.isFullscreen && currentTargetId === 'fullscreenVideo' && e.detail) {
      // 直接更新页面上的进度条显示
      const currentTime = e.detail.currentTime;
      const duration = e.detail.duration || this.data.duration;
      const progressPercent = (currentTime / duration) * 100;

      this.setData({
        currentTime: currentTime,
        progressPercent: progressPercent,
        currentTimeFormatted: this.formatTime(currentTime, true)
      });

      // 同步时间到主视频
      const mainVideoContext = wx.createVideoContext('mainVideo', this);
      if (mainVideoContext) {
        mainVideoContext.seek(currentTime);
      }
    }

    // 如果退出全屏，重置同步标记
    if (!this.data.isFullscreen) {
      this.setData({
        needsSyncAfterFullscreen: false
      });
    }
  },

  // 处理进度条点击事件
  onProgressTap(e) {
    if (this.data.processbarId) {
      clearTimeout(this.data.processbarId);
      this.setData({
        processbarId: null
      })
    }
    this.setData({
      ifShowProcessBar: true
    })
    // 如果正在拖动，不处理点击事件
    if (this.data.isDragging) {
      return;
    }

    // 在小程序中，使用selectorQuery获取元素尺寸
    const query = wx.createSelectorQuery();
    query.select('.progress-bar').boundingClientRect();
    query.exec((res) => {
      if (res && res[0]) {
        const {
          width,
          left
        } = res[0];
        // 计算点击位置相对于进度条的比例
        const tapX = e.touches[0].clientX;
        const ratio = (tapX - left) / width;

        // 计算目标时间点
        const targetTime = Math.min(Math.max(ratio * this.data.duration, 0), this.data.duration);

        // 更新进度并跳转视频位置
        this.setData({
          currentTime: targetTime,
          progressPercent: ratio * 100,
          currentTimeFormatted: this.formatTime(targetTime, true) // 启用毫秒显示
        });

        // 控制视频跳转到指定时间点
        if (this.data.videoContext) {
          this.data.videoContext.seek(targetTime);
        }
      }
    });

    this.data.processbarId = setTimeout(() => {
      this.setData({
        ifShowProcessBar: false
      })
    }, 3000)
  },

  // 触摸开始事件
  onProgressTouchStart(e) {
    if (this.data.processbarId) {
      clearTimeout(this.data.processbarId);
      this.setData({
        processbarId: null
      });
    }
    this.setData({
      ifShowProcessBar: true
    })
    this.setData({
      isDragging: true
    });

    // 如果还没有获取到进度条尺寸，先获取
    if (this.data.progressBarWidth === 0) {
      this.getProgressBarDimensions();
    }


  },

  // 触摸移动事件
  onProgressTouchMove(e) {
    // 清除所有相关定时器，包括进度条和播放/暂停相关的定时器
    if (this.data.processbarId) {
      clearTimeout(this.data.processbarId);
      this.setData({
        processbarId: null
      });
    }
    if (this.data.playorpauseProcessId) {
      clearTimeout(this.data.playorpauseProcessId);
      this.setData({
        playorpauseProcessId: null
      });
    }
    // 强制显示进度条（防止被定时器隐藏）
    this.setData({
      ifShowProcessBar: true
    });
    if (!this.data.isDragging || this.data.progressBarWidth === 0) {
      return;
    }

    // 计算触摸位置相对于进度条的比例
    const tapX = e.touches[0].clientX;
    const ratio = Math.min(Math.max((tapX - this.data.progressBarLeft) / this.data.progressBarWidth, 0), 1);

    // 计算目标时间点
    const targetTime = ratio * this.data.duration;

    // 更新进度信息
    this.setData({
      progressPercent: ratio * 100,
      currentTimeFormatted: this.formatTime(targetTime, true) // 启用毫秒显示
    });
  },

  // 触摸结束事件
  onProgressTouchEnd(e) {
    if (this.data.processbarId) {
      clearTimeout(this.data.processbarId);
      this.setData({
        processbarId: null
      })
    }
    if (!this.data.isDragging || this.data.progressBarWidth === 0) {
      return;
    }



    // 计算触摸位置相对于进度条的比例
    const tapX = e.changedTouches[0].clientX;
    const ratio = Math.min(Math.max((tapX - this.data.progressBarLeft) / this.data.progressBarWidth, 0), 1);

    // 计算目标时间点
    const targetTime = ratio * this.data.duration;

    // 更新进度并跳转视频位置
    this.setData({
      isDragging: false,
      currentTime: targetTime,
      progressPercent: ratio * 100,
      currentTimeFormatted: this.formatTime(targetTime, true) // 启用毫秒显示
    });

    // 控制视频跳转到指定时间点并暂停 - 主视频
    if (this.data.videoContext) {
      this.data.videoContext.seek(targetTime);
      this.data.videoContext.pause();
    }

    // 如果在全屏模式下，也控制全屏视频
    if (this.data.isFullscreen) {
      const fullscreenVideoContext = wx.createVideoContext('fullscreenVideo', this);
      if (fullscreenVideoContext) {
        fullscreenVideoContext.seek(targetTime);
        fullscreenVideoContext.pause();
      }
    }

    this.setData({
      isPlaying: false
    });
    this.data.processbarId = setTimeout(() => {
      this.setData({
        ifShowProcessBar: false
      })
    }, 3000)
  },

  // 截取当前视频画面并保存到相册 - 使用未压缩版视频
  takeScreenshot() {
    if (!this.data.originalVideoPath) {
      wx.showToast({
        title: '请先选择视频',
        icon: 'none'
      });
      return;
    }

    // 显示加载提示
    wx.showLoading({
      title: '正在截取画面...',
      mask: true
    });

    try {
      // 获取当前视频时间
      const currentTime = this.data.currentTime;
      console.log('截图时间点', currentTime);

      // 确保视频解码器已初始化
      if (!this.data.videoDecoder) {
        wx.showToast({
          title: '视频解码器未初始化',
          icon: 'none'
        });
        wx.hideLoading();
        return;
      }

      // 定位到当前时间点，并添加错误处理
      try {
        this.data.videoDecoder.seek(currentTime * 1000);
        console.log('成功定位到指定时间点');
      } catch (seekError) {
        console.error('定位视频时间点失败:', seekError);
        wx.hideLoading();
        wx.showToast({
          title: '截图失败，请稍后重试',
          icon: 'none'
        });
        return;
      }

      // 检查并获取帧数据
      const checkFrame = () => {
        const frameData = this.data.videoDecoder.getFrameData();
        if (frameData) {
          // 使用离屏画布绘制当前帧
          const {
            canvas,
            context
          } = this.data;
          context.clearRect(0, 0, this.data.canvasWidth, this.data.canvasHeight);
          const imgData = context.createImageData(this.data.canvasWidth, this.data.canvasHeight);

          // 拷贝帧数据
          const clampedArray = new Uint8ClampedArray(frameData.data);
          for (let i = 0; i < clampedArray.length; i++) {
            imgData.data[i] = clampedArray[i];
          }

          context.putImageData(imgData, 0, 0);

          // 将canvas内容保存为临时图片文件
          wx.canvasToTempFilePath({
            canvas: canvas,
            success: (res) => {
              // 保存到相册
              wx.saveImageToPhotosAlbum({
                filePath: res.tempFilePath,
                success: () => {
                  wx.hideLoading();
                  wx.showToast({
                    title: '截图已保存到相册',
                    icon: 'success'
                  });
                },
                fail: (err) => {
                  wx.hideLoading();
                  console.error('保存到相册失败:', err);
                  wx.showToast({
                    title: '保存失败',
                    icon: 'none'
                  });
                }
              });
            },
            fail: (err) => {
              wx.hideLoading();
              console.error('canvas转图片失败:', err);
              wx.showToast({
                title: '截图失败',
                icon: 'none'
              });
            }
          });
        } else {
          // 如果没有获取到帧数据，100ms后重试
          setTimeout(checkFrame, 100);
        }
      };

      // 开始检查帧数据
      setTimeout(checkFrame, 300);
    } catch (error) {
      wx.hideLoading();
      console.error('截图过程出错:', error);
      wx.showToast({
        title: '截图过程出错',
        icon: 'none'
      });
    }
  },

  // 停止相关进程
  stopGeneration() {
    if (this.frameTimer) {
      clearInterval(this.frameTimer);
    }
  },

  onUnload() {
    this.stopGeneration();
    if (this.data.videoDecoder) {
      this.data.videoDecoder.stop();
    }
  },
  
  // 用户授权信息按钮点击事件
  onAuthButtonClick() {
    // 显示表单弹窗
    this.setData({
      showFormModal: true
    });
  },
  
  // 关闭表单弹窗
  closeFormModal() {
    this.setData({
      showFormModal: false
    });
  },
  
  // 表单输入变化处理
  onInputChange(e) {
    const { field } = e.currentTarget.dataset;
    const { value } = e.detail;
    
    this.setData({
      [`formData.${field}`]: value
    });
  },
  
  // 提交验证表单
  submitForm() {
    const { formData } = this.data;
    
    // 简单的表单验证
    if (!formData.contestNumber || !formData.idCardLastFour || !formData.name || !formData.phone || !formData.nickname) {
      wx.showToast({
        title: '请填写完整信息',
        icon: 'none'
      });
      return;
    }
    
    // 验证手机号格式
    if (!/^1[3-9]\d{9}$/.test(formData.phone)) {
      wx.showToast({
        title: '请输入正确的手机号',
        icon: 'none'
      });
      return;
    }
    
    // 表单提交成功后的处理
    console.log('表单数据:', formData);
    console.log(typeof(formData.contestNumber))
    
    // 显示提交成功提示
    wx.showToast({
      title: '提交成功',
      icon: 'success'
    });
    
    // 关闭弹窗
    this.closeFormModal();
    
    // 可以在这里添加将表单数据发送到服务器的代码
    // 例如调用wx.request发送数据
    wx.request({
      url: 'http://192.168.126.20:5000/api/user/confirm',
      method: 'POST',
      data: {
        race_number:formData.contestNumber,
        name:formData.name,
        nickname:formData.nickname,
        personid:formData.idCardLastFour,
        phone:formData.phone,
        openid:wx.getStorageSync('openid')
      },
      success: (res) => {
        console.log("数据发送成功",res)
        this.setData({
          originalVideoPath:res.data.data.video_url
        })
        this.selectVideo(res)
      },
      fail: (err) => {
        console.error('数据发送失败:', err)
      }
    })
  },
  //获取所有我的视频（包含原视频和带特效的视频）
  //我需要在这个函数中向后端发送请求获取该用户的所有视频 以列表的形式返回结果  将结果保存在前端里
  getAllVideos(){
    wx.request({
      url: 'http://192.168.126.20:5000/api/user/video/list',
      method: 'GET',
      data: {
        openid:wx.getStorageSync('openid')//从本地获取 因为登陆的时候已经保存在本地了
      },
      success: (res) => {
        console.log("请求发送成功",res)
        console.log(res.data.data.videoList)
        const videoList = []
        for(let i = 0;i<res.data.data.videoList.length;i++){
          const video_url = res.data.data.videoList[i].video_url
          videoList.push(video_url)
        }
        this.setData({
            videoSources:videoList
        })
        console.log(this.data.videoSources)
      },
      fail: (err) => {
        console.error('数据发送失败:', err)
      }
    })
  },
  // 好友分享配置
  onShareAppMessage() {
    const shareInfo = {
      videoUrl: 'https://test-videos.co.uk/vids/bigbuckbunny/mp4/h264/720/Big_Buck_Bunny_720_10s_1MB.mp4',
      videoPoster: 'https://picsum.photos/800/450?random=3',
      videoTitle: '超有趣的动画短片',
      videoDesc: '推荐你看这个精彩视频，太有意思了！'
    };
    
    return {
      title: shareInfo.videoTitle,
      // 路径修改为新的纯观看页面
      path: `/pages/video_viewer/video_viewer?videoUrl=${encodeURIComponent(shareInfo.videoUrl)}&videoPoster=${encodeURIComponent(shareInfo.videoPoster)}&videoTitle=${encodeURIComponent(shareInfo.videoTitle)}&videoDesc=${encodeURIComponent(shareInfo.videoDesc)}`,
      imageUrl: shareInfo.videoPoster
    };
  },

  // 朋友圈分享配置
  onShareTimeline() {
    const shareInfo = {
      videoUrl: 'https://test-videos.co.uk/vids/bigbuckbunny/mp4/h264/720/Big_Buck_Bunny_720_10s_1MB.mp4',
      videoPoster: 'https://picsum.photos/800/450?random=3',
      videoTitle: '超有趣的动画短片',
      videoDesc: '推荐你看这个精彩视频，太有意思了！'
    };
    
    return {
      title: shareInfo.videoTitle,
      // 注意：朋友圈分享只能用 query 传递参数，不能用 path！
      query: `videoUrl=${encodeURIComponent(shareInfo.videoUrl)}&videoPoster=${encodeURIComponent(shareInfo.videoPoster)}&videoTitle=${encodeURIComponent(shareInfo.videoTitle)}&videoDesc=${encodeURIComponent(shareInfo.videoDesc)}&fromTimeline=1`, // 增加标识区分来源
      imageUrl: shareInfo.videoPoster
    };
  },
  checkLoginStatus() {
    const app = getApp();
    // 从全局变量或本地存储获取openid
    const openid = app.globalData.openid || wx.getStorageSync('openid');
    // 更新未登录状态：openid为空 → 未登录（isUnLogin=true）
    this.setData({
      isUnLogin: !openid // 若openid存在，isUnLogin=false（隐藏屏蔽罩）
    });
  },
  // 无水印下载（付费）- 新增支付逻辑
  downloadWithoutWatermark() {
    const videoUrl = 'https://test-videos.co.uk/vids/bigbuckbunny/mp4/h264/720/Big_Buck_Bunny_720_10s_1MB.mp4';
    const userId = wx.getStorageSync('openid');
    
    if (!userId) {
      wx.showToast({ title: '请先登录', icon: 'none' });
      return;
    }
  
    // 1. 关闭下载弹窗，显示加载
    this.closeDownloadModal();
    wx.showLoading({ title: '创建订单中...' });
  
    // 2. 调用后端创建订单接口
    wx.request({
      url: 'http://192.168.126.20:5000/api/payment/createOrder',
      method: 'POST',
      data: {
        user_id: userId,
        amount: 0.01, // 固定10元
        download_type: 'watermark_free',
        video_url: videoUrl
      },
      success: (res) => {
        wx.hideLoading();
        console.log('创建订单返回:', res.data); // 调试日志
        
        const { success, data, message } = res.data;
        if (success && data.pay_params) {
          const payParams = data.pay_params;
          
          // 3. 调试：打印支付参数
          console.log('支付参数:', payParams);
          
          // 4. 确保参数完整，特别是appId
          if (!payParams.appId) {
            wx.showToast({ title: '支付参数缺失appId', icon: 'none' });
            return;
          }
  
          // ==================== 添加参数验证代码 ====================
          // 在调用支付前添加验证
          console.log('支付参数验证:');
          console.log('timeStamp:', payParams.timeStamp, '类型:', typeof payParams.timeStamp);
          console.log('nonceStr:', payParams.nonceStr, '类型:', typeof payParams.nonceStr);
          console.log('package:', payParams.package, '类型:', typeof payParams.package);
          console.log('signType:', payParams.signType, '类型:', typeof payParams.signType);
          console.log('paySign:', payParams.paySign ? '存在' : '缺失', '长度:', payParams.paySign?.length);
  
          // 确保所有参数都是字符串
          const paymentParams = {
            timeStamp: String(payParams.timeStamp),
            nonceStr: String(payParams.nonceStr),
            package: String(payParams.package),
            signType: String(payParams.signType || 'RSA'),
            paySign: String(payParams.paySign)
          };
  
          console.log('转换后的支付参数:', paymentParams);
          // ==================== 参数验证代码结束 ====================
  
          // 5. 调起微信支付
          wx.requestPayment({
            timeStamp: paymentParams.timeStamp,        // 使用转换后的参数
            nonceStr: paymentParams.nonceStr,          // 使用转换后的参数
            package: paymentParams.package,            // 使用转换后的参数
            signType: paymentParams.signType,          // 使用转换后的参数
            paySign: paymentParams.paySign,            // 使用转换后的参数
            success: (payRes) => {
              console.log('支付成功:', payRes);
              wx.showToast({ title: '支付成功，正在下载...' });
              this.downloadWatermarkFreeVideo(videoUrl);
            },
            fail: (err) => {
              console.error('支付失败:', err);
              if (err.errMsg.includes('cancel')) {
                wx.showToast({ title: '支付取消', icon: 'none' });
              } else {
                wx.showToast({ title: '支付失败: ' + err.errMsg, icon: 'none' });
              }
            }
          });
        } else {
          wx.showToast({ title: message || '创建订单失败', icon: 'none' });
        }
      },
      fail: (err) => {
        wx.hideLoading();
        console.error('请求失败:', err);
        wx.showToast({ title: '网络错误', icon: 'none' });
      }
    });
  },

// 支付成功后下载无水印视频（新增方法）
downloadWatermarkFreeVideo(videoUrl) {
  wx.showLoading({ title: '下载无水印视频...' });
  wx.downloadFile({
    url: videoUrl, // 实际项目中应替换为无水印视频URL
    success: (res) => {
      wx.hideLoading();
      if (res.statusCode === 200) {
        wx.saveVideoToPhotosAlbum({
          filePath: res.tempFilePath,
          success: () => wx.showToast({ title: '无水印视频已保存' }),
          fail: () => wx.showToast({ title: '保存失败', icon: 'none' })
        });
      } else {
        wx.showToast({ title: '下载失败', icon: 'none' });
      }
    },
    fail: () => {
      wx.hideLoading();
      wx.showToast({ title: '下载失败', icon: 'none' });
    }
  });
},
// 显示下载选项
showDownloadOptions() {
  this.setData({ showDownloadModal: true });
},

// 关闭下载弹窗
closeDownloadModal() {
  this.setData({ showDownloadModal: false });
},

// 下载视频入口
downloadVideo() {
  const videoUrl = 'https://test-videos.co.uk/vids/bigbuckbunny/mp4/h264/720/Big_Buck_Bunny_720_10s_1MB.mp4';

  wx.getSetting({
    success: (res) => {
      if (res.authSetting['scope.writePhotosAlbum']) {
        this.handleDownload(videoUrl);
      } else {
        wx.authorize({
          scope: 'scope.writePhotosAlbum',
          success: () => this.handleDownload(videoUrl),
          fail: () => {
            wx.showModal({
              title: '授权提示',
              content: '需要开启相册权限才能保存视频',
              success: (modalRes) => {
                if (modalRes.confirm) wx.openSetting();
              }
            });
          }
        });
      }
    }
  });
},

// 实际下载逻辑
handleDownload(videoUrl) {
  this.setData({ downloadProgress: 0 });
  wx.showLoading({ title: '下载中...' });

  wx.downloadFile({
    url: videoUrl,
    onProgressUpdate: (progress) => {
      this.setData({ downloadProgress: progress.progress });
    },
    success: (downloadRes) => {
      wx.hideLoading();
      this.setData({ downloadProgress: 0 });

      if (downloadRes.statusCode === 200) {
        wx.saveVideoToPhotosAlbum({
          filePath: downloadRes.tempFilePath,
          success: () => {
            wx.showToast({ title: '带水印视频已保存' });
            this.closeDownloadModal();
          },
          fail: (err) => {
            wx.showToast({ title: '保存失败', icon: 'none' });
            console.error('保存失败：', err);
          }
        });
      } else {
        wx.showToast({ title: '下载失败', icon: 'none' });
      }
    },
    fail: (err) => {
      wx.hideLoading();
      this.setData({ downloadProgress: 0 });
      wx.showToast({ title: '网络错误', icon: 'none' });
      console.error('下载失败：', err);
    }
  });
},
});